﻿using System;
using System.Linq;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Diagnostics;
//Librerias Arquitectura
using Com.Binaria.Core;
using Com.Binaria.Core.Base;
using Com.Binaria.Core.Dto;
using Com.Binaria.Core.Util;
using Com.Binaria.Core.Datos;
using Com.Binaria.Core.Exceptions;
using Com.Binaria.Core.Enumeracion;
//Librerias Proyecto
using Com.Binaria.SISCOB.Funcional.DTO;
using Com.Binaria.SISCOB.DTO;
using Com.Binaria.SISCOB.DAO;

namespace Com.Binaria.SISCOB.Dom
{
/// <summary>
///	clase de registrodocumento dom
/// </summary>
public partial class RegistroDocumentoDom : IRegistroDocumentoDom
{
	#region campos privados
    /// <summary>
    /// Constante que almacena el prefijo de la aplicacion
    /// </summary>
    private const String CLASS_PREFIX = "Com.Binaria.SISCOB.Dom.RegistroDocumentoDom";
	#endregion
	
    #region campos publicos
        /// <summary>
        /// campo publico que contiene una instancia del objeto (RegistroDocumentoDAO) encargado del acceso a datos
        /// </summary>
        public IRegistroDocumentoDAO iRegistroDocumentoDAO;
    #endregion

    #region constructores
    /// <summary>
    /// constructor por defecto del objeto
    /// </summary>
    public RegistroDocumentoDom()
    {
		
	}
    #endregion


	
    #region metodos privados
	
	/// <summary>
    /// metodo que permite generar clonaciones de los objetos almacenados en la lista generica 
    /// </summary>
    /// <param name="p_RegistroDocumentos">lista generica con elementos registrodocumento a copiar</param>
    /// <returns>Objeto view con elementos registrodocumento copiados</returns>
    private List<RegistroDocumentoDTO> CopiaRegistroDocumento(List<RegistroDocumentoDTO> p_RegistroDocumentos)
    {
		//Prefijo del Metodo
		const string MPREFIX = " [CopiaRegistroDocumento]";
		//Crea lista de objetos de salida
        List<RegistroDocumentoDTO> RespuestaCopia = new List<RegistroDocumentoDTO>();		
        try
        {
			//Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
			//Valido que la lista no venga en NULL
            AssertNull.notNullOrEmpty(p_RegistroDocumentos);
			//Valido que la lista tenga elementos
			AssertNull.notNullOrEmpty(p_RegistroDocumentos.Count);
			//Recorro la lista de objetos
			foreach (RegistroDocumentoDTO registro in p_RegistroDocumentos)
			{
				//Valido que el registro no este vacio
				AssertNull.notNullOrEmpty(registro);
				//Agrega el registro a la lista de respuesta
				RespuestaCopia.Add(registro.Clone());
			}
            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de termino del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaCopia;
    }


    /// <summary>
    /// metodo que permite buscar todas los elementos registrodocumento existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
	/// <param name="p_Filtro">Datos para realizar una busqueda por filtros</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>
    private List<RegistroDocumentoDTO> Buscar(ContextoDTO p_Contexto, RegistroDocumentoDTO p_Filtro)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [Buscar]";
		//Crea lista de objetos de salida
        List<RegistroDocumentoDTO> RespuestaBuscar = new List<RegistroDocumentoDTO>();		
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
            //Obtengo la lista de objetos
            RespuestaBuscar = iRegistroDocumentoDAO.Find(p_Filtro);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }
	
	/// <summary>
	/// metodo que permite buscar el elemento registrodocumento que coincide con el id
	/// </summary>
	/// <param name="p_Contexto">informacion del contexto</param>
	/// <param name="p_IdRegistroDocumento">Id de la registrodocumento</param>
	/// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>
    private RegistroDocumentoDTO Buscar(ContextoDTO p_Contexto, System.Int32? p_IdRegistroDocumento)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [Buscar]";
        //Crea lista de objetos de salida
        RegistroDocumentoDTO RespuestaBuscar = new RegistroDocumentoDTO();
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
            //Obtengo la lista de objetos
            RespuestaBuscar = iRegistroDocumentoDAO.GetByID((System.Int32)p_IdRegistroDocumento);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }

	/// <summary>
	/// metodo que permite buscar todas los elementos registrodocumento existentes
	/// </summary>
	/// <param name="p_Contexto">informacion del contexto</param>
	/// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>
    private List<RegistroDocumentoDTO> Buscar(ContextoDTO p_Contexto)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [Buscar]";
		//Crea lista de objetos de salida
        List<RegistroDocumentoDTO> RespuestaBuscar = new List<RegistroDocumentoDTO>();		
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
            //Obtengo la lista de objetos
            RespuestaBuscar = iRegistroDocumentoDAO.GetAll();
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }


    /// <summary>
    /// metodo al cual se le delega la insercion de elementos de registrodocumento
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_RegistroDocumentos">elementos de tipo registrodocumento a insertar</param>
    private List<RegistroDocumentoDTO> InsertarRegistroDocumento(ContextoDTO p_Contexto, List<RegistroDocumentoDTO> p_RegistroDocumentos)
    {
		//Prefijo del Metodo
        const string MPREFIX = " [InsertarRegistroDocumento]";
        try
        {
			//Registro log de inicio del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
	
			//Valida que exista informacion a insertar
			AssertNull.notNullOrEmpty(p_RegistroDocumentos);

			//Crea objeto para almacenar los datos existentes
			List<RegistroDocumentoDTO> ListaRegistroDocumento = new List<RegistroDocumentoDTO>();

            //try
            //{
                //Obtiene la lista de RegistroDocumento
            //    ListaRegistroDocumento = Buscar(p_Contexto);
            //}
            //catch (ManagerException me)
            //{
                //Capturo el error cuando no existen datos
            //    if (!me.Message.Substring(0, me.Message.IndexOf(";")).Equals("3001"))
            //    {
            //        throw (me);
            //    }
            //}

	        //Objeto que contiene la cantidad de objetos que existen
            int cant = 0;
            foreach (RegistroDocumentoDTO RegistroDocumento in p_RegistroDocumentos)
            {
				//Valida que RegistroDocumento contenga los datos minimos
						AssertNull.notNullOrEmpty(RegistroDocumento);
												
				//Busca valores unicos que no se pueden repetir en un registro
	            //cant = ListaRegistroDocumento.Where(dto => GetMatchingByUniqueValues(dto, RegistroDocumento)).Count();

                //if (!cant.Equals(0))
                //{
                //    break;
                //}
			}

            //Valida que no existan valores unicos
            if (cant.Equals(0))
            {
                //Creo el nuevo registro y almaceno el valor devuelto en el objeto creado
                p_RegistroDocumentos = iRegistroDocumentoDAO.Insert(p_RegistroDocumentos.ToArray()).ToList();
				
				foreach (RegistroDocumentoDTO RegistroDocumento in p_RegistroDocumentos)
            	{
					//Valido que el valor devuelto corresponda a un indice
					if (RegistroDocumento.Id.Equals(0))
					{
						//Registro log de ejecucion con problemas
						Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
						//Genero error debido a que no existen datos a entregar
						throw new ManagerException(Factoria.GetMessage("DOM_ERROR_INSERTAR_BASE"), TraceEventType.Warning);
					}
				}

			}
			else
			{
				//Registro log de ejecucion con problemas
                Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
                //Genero error debido a que no existen datos a entregar
                throw new ManagerException(Factoria.GetMessage("DOM_DATOS_UNICOS_REPETIDOS"), TraceEventType.Warning);
            }

			//Registro log de termino OK del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
			//Registro log de ejecucion el termino del metodo
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
		}
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (System.Data.DBConcurrencyException dbce)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_INSERT"), dbce, TraceEventType.Error);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
		return p_RegistroDocumentos;
    }
	
    /// <summary>j
    /// metodo al cual se le delega la actualizacion de elementos de registrodocumento
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_RegistroDocumentos">elementos de tipo registrodocumento a actualizar</param>
    private void ModificarRegistroDocumento(ContextoDTO p_Contexto, List<RegistroDocumentoDTO> p_RegistroDocumentos)
    {
		//Prefijo del Metodo
		const string MPREFIX = " [ModificarRegistroDocumento]";

        try
        {
			//Registro log de inicio del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
	
			//Valida que exista informacion a insertar
			AssertNull.notNullOrEmpty(p_RegistroDocumentos);

			//Crea objeto para almacenar los datos existentes
			//List<RegistroDocumentoDTO> ListaRegistroDocumento = new List<RegistroDocumentoDTO>();

            //try
            //{
            //    //Obtiene la lista de RegistroDocumento
            //    ListaRegistroDocumento = Buscar(p_Contexto);
            //}
            //catch (ManagerException me)
            //{
            //    //Administra la estructura de errores por codigo
            //    switch (me.Message.Substring(0, me.Message.IndexOf(";")))
            //    {
            //        case "3001":
            //            throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), me, TraceEventType.Warning);
            //        default:
            //            throw(me);
            //    }
            //}

	        //Objeto que contiene la cantidad de objetos que existen
            int cant = 0;
            foreach (RegistroDocumentoDTO RegistroDocumento in p_RegistroDocumentos)
            {
				//Valida que RegistroDocumento contenga los datos minimos
						AssertNull.notNullOrEmpty(RegistroDocumento);
												
				//Busca valores unicos que no sepueden repetir en un registro
	            //cant = ListaRegistroDocumento.Where(dto => GetMatchingByUniqueValues(dto, RegistroDocumento)).Count();

                if (!cant.Equals(0))
                {
                    break;
                }
				else
				{
					//Creo objeto para recepcionar respuesta de la busqueda
					RegistroDocumentoDTO RegistroDocumentoEncontrada = new RegistroDocumentoDTO();

					try
					{
						//Realizo la busqueda en cache
						RegistroDocumentoEncontrada = Buscar(p_Contexto, (System.Int32?)RegistroDocumento.Id);
                    }
                    catch (ManagerException me)
                    {
                        //Administra la estructura de errores por codigo
                        switch (me.Message.Substring(0, me.Message.IndexOf(";")))
                        {
                            case "3001":
                                throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), me, TraceEventType.Warning);
                        }
                    }
					
					//Verifico si el registro existe en cache
					if (RegistroDocumentoEncontrada == null)
					{
						//Registro log de ejecucion con problemas
						Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
						//Genero error debido a que no existen datos a entregar
						throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), TraceEventType.Warning);
					}
				}
			}
			
			//Valida que no existan valores unicos
            if (cant.Equals(0))
            {
				//Actualizo la informacion existente
				iRegistroDocumentoDAO.Update(p_RegistroDocumentos.ToArray());

			}
			else
			{
				//Registro log de ejecucion con problemas
                Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
                //Genero error debido a que no existen datos a entregar
                throw new ManagerException(Factoria.GetMessage("DOM_DATOS_UNICOS_REPETIDOS"), TraceEventType.Warning);
                //Cambio valor de insertar a falso
            }

			//Registro log de termino OK del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
			//Registro log de ejecucion el termino del metodo
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DBConcurrencyException dbce)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_UPDATE"), dbce, TraceEventType.Error);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
		catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
    }
	
    /// <summary>
    /// metodo al cual se le delega la eliminacion de elementos de tipo registrodocumento
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_RegistroDocumentos">elementos de tipo registrodocumento a eliminar</param>
    private void EliminarRegistroDocumento(ContextoDTO p_Contexto, List<RegistroDocumentoDTO> p_RegistroDocumentos)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [EliminarRegistroDocumento]";
		
        try
        {
			//Registro log de inicio del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
			//Creo Clase para enviar los Id de aviso a eliminar
			List<System.Int32> IdRegistroDocumentos = new List<System.Int32>();
	        foreach (RegistroDocumentoDTO RegistroDocumento in p_RegistroDocumentos)
            {
				//Valida que RegistroDocumento contenga los datos minimos
				AssertNull.notNullOrEmpty(RegistroDocumento);
				AssertNull.notNullOrEmpty(RegistroDocumento.Id);

				//Creo objeto para recepcionar respuesta de la busqueda
				RegistroDocumentoDTO RegistroDocumentoEncontrada = new RegistroDocumentoDTO();

				try
				{
					//Realizo la busqueda
					RegistroDocumentoEncontrada = Buscar(p_Contexto, (System.Int32?)RegistroDocumento.Id);
				}
				catch (ManagerException me)
				{
					//Adminstra la estructura de errores por codigo
					switch (me.Message.Substring(0, me.Message.IndexOf(";")))
					{
						case "3001":
							throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), me, TraceEventType.Warning);
                        default:
                            throw(me);
					}
				}
                //Verifico si el registro existe en cache
				if (RegistroDocumentoEncontrada != null)
				{
					IdRegistroDocumentos.Add((System.Int32)RegistroDocumento.Id);
				}
            }
			
			if (IdRegistroDocumentos.Count>0)
			{
				//Elimino los registros
				iRegistroDocumentoDAO.Delete(IdRegistroDocumentos.ToArray());
			}

			//Registro log de termino OK del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
			//Registro log de ejecucion el termino del metodo
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
		}
        catch (System.Data.DBConcurrencyException dbce)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_UPDATE"), dbce, TraceEventType.Error);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
		catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
    }
	
	#region metodos privados estaticos
	/// <summary>
    /// metodo que permite buscar lo elementos de tipo registrodocumento coincidentes en base a sus propiedades que contienen valores unicos
    /// </summary>
    /// <param name="p_RegistroDocumento">elemento de tipo registrodocumento a buscar</param>
    /// <param name="p_RegistroDocumentoComparer">elemento de tipo registrodocumento a comparar</param>
    /// <returns>retorna valor booleano indicando existencia de igualdad</returns>
    private static bool GetMatchingByUniqueValues(RegistroDocumentoDTO p_RegistroDocumento, RegistroDocumentoDTO p_RegistroDocumentoComparer)
    {
		//Este metodo valida que la informacion no este repetida
		bool returnValue = false;
		returnValue = 
                (p_RegistroDocumento.IdRegistroContable.ToString().ToUpper() == p_RegistroDocumentoComparer.IdRegistroContable.ToString().ToUpper())
				&&
                (p_RegistroDocumento.IdDocumentoTransaccion.ToString().ToUpper() == p_RegistroDocumentoComparer.IdDocumentoTransaccion.ToString().ToUpper())
				&&
                (p_RegistroDocumentoComparer.Id.Equals(default(System.Int32?)) || p_RegistroDocumento.Id != p_RegistroDocumentoComparer.Id);
		return returnValue;
    }	
	
    /// <summary>
    /// metodo que permite buscar todos los elementos de tipo registrodocumento coincidentes en base a las propiedades del objeto
    /// </summary>
    /// <param name="p_RegistroDocumento">elemento de tipo registrodocumento a comparar</param>
    /// <param name="p_Filtro">filtro de elemento de tipo registrodocumento a comparar</param>
    /// <returns>retorna valor booleano indicando existencia de igualdad</returns>
    private static bool FindMatching(RegistroDocumentoDTO p_RegistroDocumento, RegistroDocumentoDTO p_Filtro)
    {
		bool returnValue = false;

		returnValue =		
                (p_Filtro.Id == null || (p_RegistroDocumento.Id == null?null: p_RegistroDocumento.Id.ToString().ToUpper()) == p_Filtro.Id.ToString().ToUpper())
				&&
                 (p_Filtro.IdRegistroContable == null || (p_RegistroDocumento.IdRegistroContable == null?null: p_RegistroDocumento.IdRegistroContable.ToString().ToUpper()) == p_Filtro.IdRegistroContable.ToString().ToUpper())					
				&&
                 (p_Filtro.IdDocumentoTransaccion == null || (p_RegistroDocumento.IdDocumentoTransaccion == null?null: p_RegistroDocumento.IdDocumentoTransaccion.ToString().ToUpper()) == p_Filtro.IdDocumentoTransaccion.ToString().ToUpper())										;

		return returnValue;
    }	
	#endregion metodos privados estaticos
	#endregion metodos privados	


	#region metodos publicos

	
	
	#region IRegistroDocumentoDom Members
	
	/// <summary>
    /// Metodo que permite buscar los elementos de tipo registrodocumento existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Filtro">informacion de filtrado para realizar la busqueda</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
	public List<RegistroDocumentoDTO> BuscarRegistroDocumentoFiltro(ContextoDTO p_Contexto, RegistroDocumentoDTO p_Filtro)
	{
		//Prefijo del Metodo
        const string MPREFIX = " [Buscar(ContextoDTO, RegistroDocumentoDTO)]";
        //Crea lista de objetos de salida
        List<RegistroDocumentoDTO> RespuestaBuscar = new List<RegistroDocumentoDTO>();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion a insertar
            AssertNull.notNullOrEmpty(p_Filtro);

			//Obtengo la lista de objetos almacenados en la base de datos
			RespuestaBuscar = Buscar(p_Contexto, p_Filtro);
				
            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
		catch (ManagerException me)
		{
            throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
	}

	/// <summary>
    /// metodo que permite buscar los elementos de tipo registrodocumento existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_IdRegistroDocumento">informacion por el Id de la tabla RegistroDocumento</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
	public RegistroDocumentoDTO BuscarRegistroDocumentoPorId(ContextoDTO p_Contexto, System.Int32? p_IdRegistroDocumento)
	{
		//Prefijo del Metodo
        const string MPREFIX = " [Buscar(ContextoDTO, RegistroDocumentoDTO)]";
        //Crea lista de objetos de salida
        RegistroDocumentoDTO RespuestaBuscar = new RegistroDocumentoDTO();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion a insertar
            AssertNull.notNullOrEmpty(p_IdRegistroDocumento);

			//Obtengo la lista de objtos almacenados en la base de datos
			RespuestaBuscar = Buscar(p_Contexto, p_IdRegistroDocumento);
            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
		catch (ManagerException me)
		{
            throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
	}

	/// <summary>
    /// metodo que permite buscar los elementos de tipo registrodocumento existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Filtro">informacion de filtrado para realizar la busqueda</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
	public List<RegistroDocumentoDTO> BuscarRegistroDocumentoTodos(ContextoDTO p_Contexto)
	{
		//Prefijo del Metodo
        const string MPREFIX = " [Buscar(ContextoDTO, RegistroDocumentoDTO)]";
        //Crea lista de objetos de salida
        List<RegistroDocumentoDTO> RespuestaBuscar = new List<RegistroDocumentoDTO>();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

			//Obtengo la lista de objetos almacenados
			RespuestaBuscar = Buscar(p_Contexto);

            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
		catch (ManagerException me)
		{
            throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
	}

    /// <summary>
    /// metodo que permite registrar elementos de tipo registrodocumento en el sistema
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_RegistroDocumento">registrodocumento a registrar (insertar, actualizar o eliminar)</param>
    /// <param name="p_Accion">Accion a realizar</param>
    public List<RegistroDocumentoDTO> RegistrarRegistroDocumento(ContextoDTO p_Contexto, List<RegistroDocumentoDTO> p_RegistroDocumentos, EnumRegistrarAccion p_Accion)
	{
        //Prefijo del Metodo
        const String MPREFIX = " [Registrar]";
		//Resultado accion insertar
		List<RegistroDocumentoDTO> Resultado_Insertar = new List<RegistroDocumentoDTO>();
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion en el objeto
            AssertNull.notNullOrEmpty(p_RegistroDocumentos);
            //Realiza la accion solicitada
            switch (p_Accion)
            {
                case EnumRegistrarAccion.Agregar:
                    Resultado_Insertar = InsertarRegistroDocumento(p_Contexto, p_RegistroDocumentos);
                    break;
                case EnumRegistrarAccion.Modificar:
                    ModificarRegistroDocumento(p_Contexto, p_RegistroDocumentos);
                    break;
                case EnumRegistrarAccion.Eliminar:
                    EliminarRegistroDocumento(p_Contexto, p_RegistroDocumentos);
                    break;
                default:
                    break;
            }
            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ManagerException me)
        {
            throw (me);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
		return Resultado_Insertar;
	}	
    #endregion IRegistroDocumentoDom Members
    #endregion metodos publicos

	}//End class RegistroDocumentoDom
}//End namespace





